package cn.seaboot.admin.core.service;

import cn.seaboot.admin.core.bean.Dictionary;
import cn.seaboot.admin.core.dao.DictionaryDao;
import cn.seaboot.admin.mvc.argument.ModifyArgument;
import cn.seaboot.admin.mvc.cache.CacheName;
import cn.seaboot.admin.mvc.cache.SmartCache;
import cn.seaboot.admin.mvc.valid.ValidationUtils;
import cn.seaboot.commons.core.Converter;
import cn.seaboot.commons.core.UUIDUtils;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * 数据字典
 *
 * @author Mr.css 2018年10月25日 上午10:44:39
 */
@Service
public class DictionaryService {

    @Resource
    private DictionaryDao dictionaryDao;

    @Resource
    private CacheManager cacheManager;

    /**
     * 增
     *
     * @param pojo pojo
     * @return affected rows
     */
    public int insert(Dictionary pojo) {
        String key = pojo.getSchemaName() + "." + pojo.getTableName() + "." + pojo.getColumnName();
        SmartCache.evict(CacheName.DICTIONARY, key);
        return dictionaryDao.insert(pojo);
    }

    /**
     * 删
     *
     * @param id ID
     * @return affected rows
     */
    public int deleteById(Integer id) {
        Dictionary dictionary = dictionaryDao.selectById(id);
        String key = dictionary.getSchemaName() + "." + dictionary.getTableName() + "." + dictionary.getColumnName();
        SmartCache.evict(CacheName.DICTIONARY, key);
        return dictionaryDao.deleteById(id);
    }

    /**
     * 改
     *
     * @param pojo pojo
     * @return affected rows
     */
    public int updateById(Dictionary pojo) {
        Dictionary dictionary = dictionaryDao.selectById(pojo.getId());
        String key = dictionary.getSchemaName() + "." + dictionary.getTableName() + "." + dictionary.getColumnName();
        SmartCache.evict(CacheName.DICTIONARY, key);
        return dictionaryDao.updateSampleById(pojo);
    }

    /**
     * 快捷更新
     *
     * 像是用户信息这些内容，可以输入之后，立即保存的方式做，这时候可以使用这个接口。
     *
     * @param arg 字段信息
     * @return affected rows
     */
    public int updateFieldById(ModifyArgument arg){
        Dictionary dictionary = dictionaryDao.selectById(arg.getIdInt());
        String key = dictionary.getSchemaName() + "." + dictionary.getTableName() + "." + dictionary.getColumnName();
        SmartCache.evict(CacheName.DICTIONARY, key);
        ValidationUtils.validArgument(arg, Dictionary.class);
        return dictionaryDao.updateFieldById(arg);
    }

    /**
     * 删
     *
     * @param tableName  表名
     * @param columnName 列名
     * @return affected rows
     */
    public int deleteByTableName(String schemaName, String tableName, String columnName){
        String key = schemaName + "." + tableName + "." + columnName;
        SmartCache.evict(CacheName.DICTIONARY, key);
        return dictionaryDao.deleteByTableName(schemaName, tableName, columnName);
    }

    /**
     * 查询全部
     *
     * @return pojo
     */
    public List<Dictionary> selectAll(String schemaName) {
        return dictionaryDao.selectAll(schemaName);
    }

    /**
     * 查
     *
     * @param id id
     * @return pojo
     */
    public Dictionary queryById(Integer id) {
        return dictionaryDao.selectById(id);
    }

    /**
     * 字典通用入口，确保为value,label格式即可
     *
     * @param tableName  表名
     * @param columnName 列名
     * @return pojo
     */
    @Cacheable(cacheNames = CacheName.DICTIONARY, key = "#schemaName + '.' + #tableName + '.' +  #columnName")
    public List<Dictionary> queryByType(String schemaName, String tableName, String columnName) {
        List<Dictionary> dicList = dictionaryDao.selectByType(schemaName, tableName, columnName);
        for (Dictionary dic : dicList) {
            if ("Integer".equals(dic.getValueType())) {
                dic.setValue(Converter.toInteger(dic.getValue()));
            } else if ("Boolean".equals(dic.getValueType())) {
                dic.setValue(Converter.toBool(dic.getValue()));
            }
        }
        return dicList;
    }

    /**
     * 如果导入的文件中，字段为字典的Label值，数据入库时，需要此函数做数据转换
     *
     * @param list  数据字典
     * @param value 值
     */
    public String getLabelByValue(Object value, List<Dictionary> list) {
        if (value == null) {
            return null;
        } else {
            for (Dictionary dic : list) {
                if (dic.getValue().equals(value)) {
                    return dic.getLabel();
                }
            }
            return value.toString();
        }
    }
}

//     /**
//      * 如果导入的文件中，字段为字典的Label值，数据入库时，需要此函数做数据转换
//      *
//      * @param list  数据字典
//      * @param label 标签值
//      */
//     public Integer getValueByLabel(List<Dictionary> list, String label) {
//         for (Dictionary dic : list) {
//             if (dic.getLabel().equals(label)) {
//                 return dic.getValue();
//             }
//         }
//         return null;
//     }
//     /**
//      * 转为常量字段，数据库中配置的常量名称，作为map的key值，map.value为字典值
//      *
//      * @param sort 类型
//      * @return map
//      */
//     public Map<String, Object> queryAsConstantMap(String sort) {
//         List<Dictionary> l = this.queryByType(sort);
//         Map<String, Object> map = new HashMap<>(l.size());
//         for (Dictionary d : l) {
//             map.put(d.getConstName(), d.getValue());
//         }
//         return map;
//     }
//
//     /**
//      * 将数据字典转为Map，，map.key为字典值，map.value为字典标签
//      *
//      * @param sort 类型
//      * @return map
//      */
//     public Map<Integer, Object> queryAsValueLabelMap(String sort) {
//         List<Dictionary> l = this.queryByType(sort);
//         Map<Integer, Object> map = new HashMap<>(l.size());
//         for (Dictionary d : l) {
//             map.put(d.getValue(), d.getLabel());
//         }
//         return map;
//     }

//     /**
//      * 如果导入的文件中，字段为字典的Label值，数据入库时，需要此函数做数据转换
//      *
//      * @param sort  数据字典
//      * @param value 值
//      */
//     public String getLabelByValue(String sort, Integer value) {
//         List<Dictionary> dicList = cacheService.getValueByEl(SystemConstant.CACHE_DEF, "'Dictionary' + #sort", "sort", sort);
//         if (dicList == null) {
//             dicList = this.queryByType(sort);
//         }
//         return getLabelByValue(dicList, value);
//     }

//
//     /**
//      * 如果导入的文件中，字段为字典的Label值，数据入库时，需要此函数做数据转换
//      *
//      * @param sort  数据字典
//      * @param label 标签值
//      */
//     public Integer getValueByLabel(String sort, String label) {
//         List<Dictionary> dicList = cacheService.getValueByEl(SystemConstant.CACHE_DEF, "'Dictionary' + #sort", "sort", sort);
//         if (dicList == null) {
//             dicList = this.queryByType(sort);
//         }
//         return getValueByLabel(dicList, label);
//     }
//

